#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
using namespace std;

enum
{
    FILE_NOT_EXISTS = 1,
    OPEN_FILE_ERROR = 2,

};

const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;

// 全局的命令行参数表
char *gargv[argvnum];
int gargc = 0;

// 我自己的环境变量
char *genv[envnum];

// 全局变量,用来表示退出结果
int lastcode = 0;

// 全局的工作路径
char pwd[basesize];
char pwdenv[basesize * 2];

// 全局变量与重定向有关
#define NoneRedir 0   // 没有重定向
#define InputRedir 1  // 输入重定向
#define OutputRedir 2 // 输出重定向
#define AppRedir 3    // 追加重定向

int redir = NoneRedir;
char *filename = nullptr;

// #define TrimSpace(pos) \
//     do                 \
//     {                  \
//         pos++;         \
//     \pos))
// isspace检查字符是否为空格
#define TrimSpace(pos)             \
    do                             \
    {                              \
        while (isspace(*pos))      \
        {                          \
            pos++;                 \
        }                          \
    } while (0)

string GetName()
{
    string name = getenv("USER");
    return name.empty() ? "None" : name;
}

string GetHostName()
{
    char hostname[basesize];
    gethostname(hostname, sizeof(hostname));
    return gethostname(hostname, sizeof(hostname)) != 0 ? "None" : hostname;
}

string GetPwd()
{
    // getcwd获取当前工作路径
    if (nullptr == getcwd(pwd, sizeof(pwd)))
        return "None";
    // 讲获取的当前路径输入到pwdenv
    snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);
    // 导入环境变量
    putenv(pwdenv);
    return pwd;
    // string pwd = getenv("PWD");
    // return pwd.empty() ? "None" : pwd;
}

string LastDir()
{
    string curr = GetPwd();
    if (curr == "/" || curr == "None")
        return curr;
    // /home/xzl/xxx
    size_t pos = curr.rfind("/");
    if (pos == std::string::npos)
        return curr;
    return curr.substr(pos + 1);
}

string MakeCommandLine()
{
    char Command_Line[basesize];
    snprintf(Command_Line, basesize, "[%s@%s %s]#",
             GetName().c_str(), GetHostName().c_str(), LastDir().c_str());
    return Command_Line;
}

// 打印命令行提示符
void PrintCommandLine()
{
    printf("%s", MakeCommandLine().c_str());
    fflush(stdout);
}
// 获取用户命令
bool GetCommandLine(char command_buffer[])
{
    // 获取字符串
    char *result = fgets(command_buffer, basesize, stdin);
    if (!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer) - 1] = 0;
    if (strlen(command_buffer) == 0)
        return false;
    return true;
}

//  分析命令
void ParseCommandLine(char command_buffer[], int len)
{
    memset(gargv, 0, sizeof(gargc));
    gargc = 0;

    // 重定向
    redir = NoneRedir;
    filename = nullptr;
    // printf("command start: %s\n", command_buffer);
    //"ls -a -n -l"
    //"ls -a -n -l" > file.txt
    //"ls -a -n -l" < file.txt
    //"ls -a -n -l" >> file.txt
    // ls -a -n -l <
    int end = len - 1;
    while (end >= 0)
    {
        if (command_buffer[end] == '<')
        {
            redir = InputRedir;
            command_buffer[end] = 0;
            char *filestart = &command_buffer[end];
            filestart++;
            TrimSpace(filestart);
            if (*filename == 0)
            {
                filename = nullptr;
            }
            break;
        }
        else if (command_buffer[end] == '>')
        {
            if (command_buffer[end - 1] == '>')
            {
                redir = AppRedir;
                command_buffer[end] = 0;
                command_buffer[end - 1] = 0;
                filename = &command_buffer[end];
                filename++;
                TrimSpace(filename);
                if (*filename == 0)
                {
                    filename = nullptr;
                }
                break;
            }
            else
            {
                redir = OutputRedir;
                command_buffer[end] = 0;
                filename = &command_buffer[end];
                filename++;
                TrimSpace(filename);
                if (*filename == 0)
                {
                    filename = nullptr;
                }
                break;
            }
        }
        else
        {
            end--;
        }
    }

    // printf("redir: %d\n", redir);
    // printf("filename: %s\n", filename);
    // printf("command end: %s\n", command_buffer);

    const char *seq = " ";
    gargv[gargc++] = strtok(command_buffer, seq);
    while (gargv[gargc++] = strtok(nullptr, seq))
        ;
    gargc--;
}

void debug()
{
    printf("argc: %d\n", gargc);
    for (int i = 0; gargv[i]; i++)
    {
        printf("argv[%d]: %s\n", i, gargv[i]);
    }
}

// 执行命令
bool ExecuteCommand()
{
    pid_t id = fork();
    if (id < 0)
        return false;
    else if (id == 0)
    {
        // 重定向由子进程来做，不能影响shell
        // 程序替换会不会影响重定向
        // 0.先判断  重定向
        //printf("filename:%p\n", &filename);
        if (redir == InputRedir)
        {
            if (filename)
            {
                int fd = open(filename, O_RDONLY);
                if (fd < 0)
                {
                    exit(OPEN_FILE_ERROR);
                }
                dup2(fd, 0);
            }
            else
            {
                exit(FILE_NOT_EXISTS);
            }
        }
        else if (redir == OutputRedir)
        {
            if (filename)
            {
                int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
                if (fd < 0)
                {
                    exit(OPEN_FILE_ERROR);
                }
                dup2(fd, 1);
            }
            else
            {
                exit(FILE_NOT_EXISTS);
            }
        }
        else if (redir == AppRedir)
        {
            if (filename)
            {
                int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666);
                if (fd < 0)
                {
                    exit(OPEN_FILE_ERROR);
                }
                dup2(fd, 1);
            }
            else
            {
                exit(FILE_NOT_EXISTS);
            }
        }
        else
        {
            // 没有重定向
        }

        // 子进程
        // 执行命令
        execvpe(gargv[0], gargv, genv);
        // 退出
        exit(0);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0)
    {
        if (WIFEXITED(status))
        {
            lastcode = WEXITSTATUS(status);
        }
        else // 表示代码异常退出
        {
            lastcode = 100;
        }
        return true;
    }
    return false;
}

void AddEnv(const char *item)
{
    int index = 0;
    while (genv[index])
    {
        index++;
    }
    genv[index] = (char *)malloc(strlen(item) + 1);
    strncpy(genv[index], item, strlen(item) + 1);
    index++;
    genv[index] = nullptr;
}

// 在shell中
// 有些命令，必须由子进程执行
// 有些命令，不能由子进程执行，要由shell自己执行 -----内建命令 built command
bool CheckAndExecBuiltCommand()
{
    // 不能让子进程进行，因为子进程退出就结束了，并不能影响下一个进程的工作路径
    if (strcmp(gargv[0], "cd") == 0)
    {
        if (gargc == 2)
        {
            chdir(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if (strcmp(gargv[0], "export") == 0)
    {
        if (gargc == 2)
        {
            AddEnv(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 2;
        }
    }
    else if (strcmp(gargv[0], "env") == 0)
    {
        for (int i = 0; genv[i]; i++)
        {
            printf("%s\n", genv[i]);
        }
        lastcode = 0;
        return true;
    }
    else if (strcmp(gargv[0], "echo") == 0)
    {
        if (gargc == 2)
        {
            // echo $?
            // echo $PATH
            // echo hello
            if (gargv[1][0] == '$')
            {
                if (gargv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    lastcode = 0;
                }
            }
            else
            {
                printf("%s\n", gargv[1]);
                lastcode = 0;
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }
    return false;
}

// 作为一个shell，获取环境变量应该从系统环境变量获取
// 今天外面做不到就直接从父进程shell中获取环境变量
void InitEnv()
{
    extern char **environ;
    int index = 0;
    while (environ[index])
    {
        genv[index] = (char *)malloc(strlen(environ[index]) + 1);
        strncpy(genv[index], environ[index], strlen(environ[index]));
        index++;
    }
    genv[index] = nullptr;
}

int main()
{
    // 初始化环境变量表
    InitEnv();
    char command_buffer[basesize];
    while (true)
    {
        // 打印命令行提示符
        PrintCommandLine();
        // 获取用户命令
        if (!GetCommandLine(command_buffer))
        {
            continue;
        }
        //printf("%s\n", command_buffer);
        //  分析命令
        ParseCommandLine(command_buffer, strlen(command_buffer));

        // 判断是不是内建命令
        if (CheckAndExecBuiltCommand())
        {
            continue;
        }
        // debug();
        // 执行命令
        ExecuteCommand();
    }
    return 0;
}
